#include "iostream"
using namespace std;

//class Stack
//{
//public:
//	Stack(int* a = nullptr, int size = 0, int capicity = 0)
//		:_a(a)
//		, _size(size)
//		, _capicity(capicity)
//	{
//		//if (!_a)
//		//{
//		//	_a = new int[capicity];
//		//}
//		cout << "Stack()" << endl;
//	}
//	~Stack()
//	{
//		delete[] _a;
//		_size = 0;
//		_capicity = 0;
//		cout << "~Stack()" << endl;
//	}
//private:
//	int* _a;
//	int _size;
//	int _capicity;
//};
// 
//
//int main()
//{
//	int* p1 = new int[5];
//	for (int i = 0; i < 5; i++)
//	{
//		p1[i] = i;
//		cout << p1[i] << " ";
//	}
//	cout << endl;
//	delete[] p1;
//
//	Stack* st1 = new Stack[3];
//	delete[] st1;
//
//	return 0;
//}

//void func(void)
//{
//	void* p1 = new char[1024 * 1024 * 1024];
//}
//
//int main()
//{
//	void* p1 = malloc(1024 * 1024 * 1024);
//	if (!p1)
//	{
//		cout << p1 << endl;
//	}
//	void* p2 = malloc(1024 * 1024 * 1024);
//	if (!p2)
//	{
//		cout << p2 << endl;
//	}
//
//	try
//	{
//		func();
//	}
//	catch (exception& e)
//	{
//		cout<<e.what();
//	}
//
//
//	return 0;
//}

//class Stack1
//{
//public:
//	Stack1(int* a = nullptr, int size = 0, int capicity = 0)
//		:_a(a)
//		, _size(size)
//		, _capicity(capicity)
//	{
//		cout << "Stack1()" << endl;
//	}
//	~Stack1()
//	{
//		operator delete(_a);
//		_size = 0;
//		_capicity = 0;
//		cout << "~Stack1()" << endl;
//	}
//private:
//	int* _a;
//	int _size;
//	int _capicity;
//};
//
//int main()
//{
//	int* p = (int*)operator new(5 * sizeof(int));
//	Stack1 s1(p, 0, 5);
//	
//	return 0;
//}

//template<class T>
//void Swap(T& a, T& b)
//{
//	T tmp = 0;
//	tmp = a;
//	a = b;
//	b = tmp;
//}
//
//int main()
//{
//	int m = 2, n = 4;
//	cout << m << " " << n << endl;
//	Swap(m, n);
//	cout << m << " " << n << endl;
//	double m1 = 2.2, n1 = 4.4;
//	cout << m1 << " " << n1 << endl;
//	Swap(m1, n1);
//	cout << m1 << " " << n1 << endl;
//	return 0;
//}

//template<class T>
//class Stack1
//{
//public:
//	Stack1(T* a = nullptr, int size = 0, int capicity = 2,T* a1= nullptr)
//		:_a(a)
//		, _size(size)
//		, _capicity(capicity)
//	{
//		if (!_a)
//		{
//			_a = (T*)operator new(capicity * sizeof(T));
//		}
//		while (_size < _capicity)
//		{
//			_a[_size] = a1[_size];
//			cout << _a[_size] << " ";
//			_size++;
//		}
//		cout << "Stack1()" << endl;
//	}
//
//	~Stack1()
//	{
//		operator delete(_a);
//		_size = 0;
//		_capicity = 0;
//		cout << "~Stack1()" << endl;
//	}
//private:
//	T* _a;
//	int _size;
//	int _capicity;
//};
//
//int main()
//{
//	int arr1[4] = {1,2,3,4};
//	int* p1 = arr1;
//	double arr2[4] = { 1.2,2.3,3.5,4.9 };
//	double* p2 = arr2;
//	Stack1<int> s1(nullptr,0,4,arr1);
//	Stack1<double> s2(nullptr, 0, 4,arr2);
//
//	Stack* obj1 = (Stack*)operator new(sizeof(Stack));
//	new(obj1)Stack();
//
//	return 0;
//}

struct ListNode
{
	ListNode(int val=0)
		:_val(val)
		,_prev(nullptr)
		,_next(nullptr)
	{
		cout << "ListNode()" << endl;
	}

	void* operator new(size_t n)
	{
		void* p = nullptr;
		p = allocator<ListNode>().allocate(1);
		cout << "memory pool allocator" << endl;
		return p;
	}

	void operator delete(void* p)
	{
		allocator<ListNode>().deallocate((ListNode*)p, 1);
		cout << "memory pool deallocate" << endl;
	}

	int _val;
	ListNode* _prev;
	ListNode* _next;
};

class List
{
public:
	List()
	{
		_head = new ListNode;
		_head->_next = _head;
		_head->_prev = _head;
	}
	void pushback(int val)
	{
		ListNode* newnode = new ListNode(val);
		ListNode* tail = _head->_prev;

		//head   tail   newnode
		tail->_next = newnode;
		newnode->_prev = tail;
		newnode->_next = _head;
		_head->_prev = newnode;
	}
	void Clear()
	{
		ListNode* cur = _head->_next;
		while (cur != _head)
		{
			ListNode* next = cur->_next;
			delete cur;
			cur = next;
		}

		_head->_next = _head;
		_head->_prev = _head;
	}
	void print()
	{
		ListNode* next = _head->_next;
		while (next != _head)
		{
			ListNode* nextnext = next->_next;
			cout << next->_val << " ";
			next = nextnext;
		}
		cout << endl;
	}
	~List()
	{
		Clear();
		delete _head;
		_head = nullptr;
	}
private:
	ListNode* _head;
};

int main()
{
	List l;
	int n = 0;
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		l.pushback(i);
	}
	l.print();

	return 0;
}